#include<iostream>
#include<string>
using namespace std;

/*赋值兼容规则
1.子类的对象可以赋给父类的对象，这是是把子类对象中从对应父类中的继承来的成员赋值给其父类。
  反过来不行，因为子类的新成员无值可赋；
2.可以将一个子类对象的地址赋给其父类的指针变量，但只能通过这个指针访问子类中从父类继承来的成员，
  不能访问子类中的新成员。同样也不能反过来做；
3.子类对象可以初始化父类的引用。引用是别名，但这个别名只能包含子类对象中的由父类继承来的成员。
*/

/*class Person{
public:
	int x;
	int y;
};

class Stu:public Person{
public:
	int k;
};

int main()
{
//1.
	Person p;
	Stu s;
	s.x = 10;
	s.y = 20;
	s.k = 30;
	p = s; // p.x = s.x;  p.y = s.y;  p没有k成员，因此无法访问新增成员k
	cout << p.x << "  ";
	cout << p.y << endl;
	
//2.
	Person *per;
	per = &s;
	cout << per->x << "  ";
	cout << per->y << endl;
	
//3.
	Person &pn = s;
	cout << pn.x << "  ";
	cout << pn.y << endl;
	
	return 0;
}*/

/*多态
1.编译时多态（静态多态）---> 通过函数重载和运算符重载实现
2.运行时多态（动态多态）---> 通过继承关系+虚函数(父类函数前加virtual)+指针/引用(赋值兼容规则的2和3)实现
【注】引用实现多态只能通过函数传递的形式实现，因为已经定义的引用，不能再是别的变量的引用。
3.含有纯虚函数的类叫做抽象类，不能创建对象!!!
  抽象类里可以写普通成员和函数
  e.g virtual void area() = 0; 纯虚函数无函数体
*/

/*class Animal{
public:
	virtual void cry(){
		cout << "speak..!" << "  ";
	}
};

class Cat:public Animal{
public:
	void cry(){
		cout << "miao..!" << "  ";
	}
};

class Dog:public Animal{
public:
	void cry(){
		cout << "wang..!" << "  ";
	}
};

void fun(Animal &a){a.cry();}

int main(){
	Animal *a;
	Cat c;
	Dog d;
	
//指针
	a = &c;
	a->cry();
	a = &d;
	a->cry();
	
//引用
	fun(c);
	fun(d);
	
	return 0;
}*/

/*class Shape{ //抽象类
public:
	virtual void area()=0; //纯虚函数-->无函数体
};

class Circle:public Shape{
	double r;
public:
	Circle(double R){ r = R; }
	void area(){ cout << r * r * 3.14 << endl; }
};

class Rect:public Shape{
	double w;
	double h;
public:
	Rect(double sw, double sh){
		w = sw;
		h = sh;
	}
	void area(){ cout << w * h << endl; }
};

int main(){
	Shape *p;
	Circle c(3.0);
	Rect r(2.5, 2.0);
	
	p = &c;
	p->area();
	p = &r;
	p->area();
	
	return 0;
}*/
